home *** CD-ROM | disk | FTP | other *** search
/ Motor Sport Digital Archive Collection 1960s / Motor Sport Digital Archive Collection 1960s.iso / main.swf / scripts / mx / messaging / channels / PollingChannel.as < prev   
Encoding:
Text File  |  2008-05-21  |  10.8 KB  |  355 lines
  1. package mx.messaging.channels
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.TimerEvent;
  5.    import flash.utils.Timer;
  6.    import mx.core.mx_internal;
  7.    import mx.logging.Log;
  8.    import mx.messaging.Channel;
  9.    import mx.messaging.Consumer;
  10.    import mx.messaging.MessageAgent;
  11.    import mx.messaging.MessageResponder;
  12.    import mx.messaging.events.ChannelFaultEvent;
  13.    import mx.messaging.messages.AbstractMessage;
  14.    import mx.messaging.messages.AsyncMessage;
  15.    import mx.messaging.messages.CommandMessage;
  16.    import mx.messaging.messages.IMessage;
  17.    import mx.utils.Translator;
  18.    
  19.    use namespace mx_internal;
  20.    
  21.    public class PollingChannel extends Channel
  22.    {
  23.       private static const TRANSLATOR:Translator = Translator.getDefaultInstanceFor(PollingChannel);
  24.       
  25.       private var _pollingEnabled:Boolean;
  26.       
  27.       private var _timer:Timer;
  28.       
  29.       protected var _shouldPoll:Boolean;
  30.       
  31.       private var _pollingRef:int = -1;
  32.       
  33.       public function PollingChannel(param1:String, param2:String)
  34.       {
  35.          _pollingRef = -1;
  36.          super(param1,param2);
  37.          _pollingEnabled = true;
  38.          _shouldPoll = false;
  39.          if(timerRequired())
  40.          {
  41.             _timer = new Timer(3000);
  42.             _timer.addEventListener(TimerEvent.TIMER,internalPoll);
  43.          }
  44.       }
  45.       
  46.       protected function timerRequired() : Boolean
  47.       {
  48.          return true;
  49.       }
  50.       
  51.       protected function startPolling() : void
  52.       {
  53.          if(_pollingEnabled)
  54.          {
  55.             _shouldPoll = true;
  56.             if(Log.isInfo())
  57.             {
  58.                _log.info("\'{0}\' channel polling started.",id);
  59.             }
  60.             if(_timer != null)
  61.             {
  62.                _timer.start();
  63.             }
  64.          }
  65.          else
  66.          {
  67.             if(Log.isError())
  68.             {
  69.                _log.error("\'{0}\' channel polling error.",id);
  70.             }
  71.             dispatchEvent(ChannelFaultEvent.createEvent(this,false,"Channel.Polling.Error","error",TRANSLATOR.textOf("pollingRequestNotAllowed",id)));
  72.          }
  73.       }
  74.       
  75.       protected function get internalPollingEnabled() : Boolean
  76.       {
  77.          return _pollingEnabled;
  78.       }
  79.       
  80.       protected function internalPoll(param1:Event = null) : void
  81.       {
  82.          var n:int = 0;
  83.          var i:int = 0;
  84.          var agents:Array = null;
  85.          var agentLength:int = 0;
  86.          var j:int = 0;
  87.          var agent:Object = null;
  88.          var cons:Consumer = null;
  89.          var msg:CommandMessage = null;
  90.          var event:Event = param1;
  91.          if(Log.isInfo())
  92.          {
  93.             _log.info("\'{0}\' channel requesting queued messages.",id);
  94.          }
  95.          n = int(channelSets.length);
  96.          i = 0;
  97.          while(i < n)
  98.          {
  99.             agents = channelSets[i].messageAgents;
  100.             agentLength = int(agents.length);
  101.             j = 0;
  102.             while(j < agentLength)
  103.             {
  104.                agent = agents[j];
  105.                if(agent is Consumer && Consumer(agent).subscribed)
  106.                {
  107.                   cons = Consumer(agent);
  108.                   msg = new CommandMessage();
  109.                   msg.operation = CommandMessage.POLL_OPERATION;
  110.                   msg.clientId = cons.clientId;
  111.                   msg.destination = cons.destination;
  112.                   if(cons.subtopic.length > 0)
  113.                   {
  114.                      msg.headers[AsyncMessage.SUBTOPIC_HEADER] = cons.subtopic;
  115.                   }
  116.                   if(cons.requestTimeout > 0)
  117.                   {
  118.                      msg.headers[AbstractMessage.REQUEST_TIMEOUT_HEADER] = cons.requestTimeout;
  119.                   }
  120.                   if(cons.timestamp > msg.timestamp)
  121.                   {
  122.                      msg.timestamp = cons.timestamp;
  123.                   }
  124.                   msg.messageRefType = cons.messageType;
  125.                   if(Log.isDebug())
  126.                   {
  127.                      _log.debug("\'{0}\' channel sending poll message\n{1}\n",id,msg.toString());
  128.                   }
  129.                   try
  130.                   {
  131.                      internalSend(new PollCommandMessageResponder(cons,msg,this));
  132.                   }
  133.                   catch(e:Error)
  134.                   {
  135.                      mx_internal::stopPolling();
  136.                      throw e;
  137.                   }
  138.                }
  139.                j++;
  140.             }
  141.             i++;
  142.          }
  143.       }
  144.       
  145.       protected function set internalPollingEnabled(param1:Boolean) : void
  146.       {
  147.          _pollingEnabled = param1;
  148.          if(!param1 && timerRunning)
  149.          {
  150.             mx_internal::stopPolling();
  151.          }
  152.          else if(param1 && !timerRunning && _shouldPoll)
  153.          {
  154.             startPolling();
  155.          }
  156.       }
  157.       
  158.       final override protected function getMessageResponder(param1:MessageAgent, param2:IMessage) : MessageResponder
  159.       {
  160.          var _loc3_:MessageResponder = null;
  161.          var _loc4_:CommandMessage = null;
  162.          _loc3_ = null;
  163.          if(param1 is Consumer && param2 is CommandMessage)
  164.          {
  165.             _loc4_ = CommandMessage(param2);
  166.             if(_loc4_.operation == CommandMessage.SUBSCRIBE_OPERATION || _loc4_.operation == CommandMessage.UNSUBSCRIBE_OPERATION)
  167.             {
  168.                _loc3_ = getPollSyncMessageResponder(Consumer(param1),_loc4_);
  169.             }
  170.             else if(_loc4_.operation == CommandMessage.POLL_OPERATION)
  171.             {
  172.                _loc3_ = new PollCommandMessageResponder(Consumer(param1),param2,this);
  173.             }
  174.          }
  175.          return _loc3_ == null ? getDefaultMessageResponder(param1,param2) : _loc3_;
  176.       }
  177.       
  178.       public function disablePolling() : void
  179.       {
  180.          --_pollingRef;
  181.          if(_pollingRef < 0)
  182.          {
  183.             mx_internal::stopPolling();
  184.          }
  185.       }
  186.       
  187.       public function poll() : void
  188.       {
  189.          internalPoll();
  190.       }
  191.       
  192.       protected function get internalPollingInterval() : Number
  193.       {
  194.          return _timer == null ? 0 : _timer.delay;
  195.       }
  196.       
  197.       override protected function internalDisconnect(param1:Boolean = false) : void
  198.       {
  199.          mx_internal::stopPolling();
  200.          super.internalDisconnect(param1);
  201.       }
  202.       
  203.       protected function getPollSyncMessageResponder(param1:Consumer, param2:CommandMessage) : MessageResponder
  204.       {
  205.          return null;
  206.       }
  207.       
  208.       protected function applyPollingSettings(param1:XML) : void
  209.       {
  210.          var _loc2_:XML = null;
  211.          if(param1.properties.length())
  212.          {
  213.             _loc2_ = param1.properties[0];
  214.             if(_loc2_["polling-enabled"].length())
  215.             {
  216.                internalPollingEnabled = _loc2_["polling-enabled"].toString() == "true";
  217.             }
  218.             if(_loc2_["polling-interval-seconds"].length())
  219.             {
  220.                internalPollingInterval = parseInt(_loc2_["polling-interval-seconds"].toString()) * 1000;
  221.             }
  222.          }
  223.       }
  224.       
  225.       override protected function connectFailed(param1:ChannelFaultEvent) : void
  226.       {
  227.          mx_internal::stopPolling();
  228.          super.connectFailed(param1);
  229.       }
  230.       
  231.       public function enablePolling() : void
  232.       {
  233.          ++_pollingRef;
  234.          if(_pollingRef == 0)
  235.          {
  236.             startPolling();
  237.          }
  238.       }
  239.       
  240.       protected function get timerRunning() : Boolean
  241.       {
  242.          return _timer != null && _timer.running;
  243.       }
  244.       
  245.       mx_internal function stopPolling() : void
  246.       {
  247.          if(Log.isInfo())
  248.          {
  249.             _log.info("\'{0}\' channel polling stopped.",id);
  250.          }
  251.          if(_timer != null)
  252.          {
  253.             _timer.stop();
  254.          }
  255.          _pollingRef = -1;
  256.          _shouldPoll = false;
  257.       }
  258.       
  259.       protected function getDefaultMessageResponder(param1:MessageAgent, param2:IMessage) : MessageResponder
  260.       {
  261.          return super.getMessageResponder(param1,param2);
  262.       }
  263.       
  264.       protected function set internalPollingInterval(param1:Number) : void
  265.       {
  266.          if(param1 > 0)
  267.          {
  268.             if(_timer != null)
  269.             {
  270.                _timer.delay = param1;
  271.                if(!timerRunning && _shouldPoll)
  272.                {
  273.                   startPolling();
  274.                }
  275.             }
  276.             return;
  277.          }
  278.          throw new ArgumentError(TRANSLATOR.textOf("pollingIntervalNonPositive"));
  279.       }
  280.    }
  281. }
  282.  
  283. import mx.core.mx_internal;
  284. import mx.messaging.Consumer;
  285. import mx.messaging.MessageResponder;
  286. import mx.messaging.events.ChannelFaultEvent;
  287. import mx.messaging.messages.AcknowledgeMessage;
  288. import mx.messaging.messages.CommandMessage;
  289. import mx.messaging.messages.ErrorMessage;
  290. import mx.messaging.messages.IMessage;
  291. import mx.utils.Translator;
  292.  
  293. use namespace mx_internal;
  294.  
  295. class PollCommandMessageResponder extends MessageResponder
  296. {
  297.    private static const TRANSLATOR:Translator = Translator.getMessagingInstance();
  298.    
  299.    private static const NOT_SUBSCRIBED_CODE:String = "Server.Processing.NotSubscribed";
  300.    
  301.    public function PollCommandMessageResponder(param1:Consumer, param2:IMessage, param3:PollingChannel)
  302.    {
  303.       super(param1,param2,param3);
  304.    }
  305.    
  306.    override protected function resultHandler(param1:IMessage) : void
  307.    {
  308.       var _loc2_:Array = null;
  309.       var _loc3_:ErrorMessage = null;
  310.       if(param1 is CommandMessage && param1.body != null)
  311.       {
  312.          _loc2_ = param1.body as Array;
  313.          Consumer(agent).mx_internal::dispatchMessageList(_loc2_);
  314.       }
  315.       else if(!(param1 is AcknowledgeMessage))
  316.       {
  317.          _loc3_ = new ErrorMessage();
  318.          _loc3_.faultDetail = TRANSLATOR.textOf("receivedNull");
  319.          status(_loc3_);
  320.       }
  321.    }
  322.    
  323.    override protected function statusHandler(param1:IMessage) : void
  324.    {
  325.       var _loc2_:ErrorMessage = null;
  326.       var _loc3_:Consumer = null;
  327.       var _loc4_:String = null;
  328.       var _loc5_:ChannelFaultEvent = null;
  329.       _loc2_ = param1 as ErrorMessage;
  330.       if(_loc2_ != null && _loc2_.faultCode == NOT_SUBSCRIBED_CODE)
  331.       {
  332.          PollingChannel(channel).disablePolling();
  333.          _loc3_ = Consumer(agent);
  334.          if(_loc3_.subscribed)
  335.          {
  336.             _loc3_.disconnect();
  337.             _loc3_.subscribe();
  338.          }
  339.          else
  340.          {
  341.             _loc3_.fault(_loc2_,message);
  342.             _loc3_.disconnect();
  343.          }
  344.       }
  345.       else
  346.       {
  347.          PollingChannel(channel).mx_internal::stopPolling();
  348.          _loc4_ = _loc2_ != null ? _loc2_.faultDetail : "";
  349.          _loc5_ = ChannelFaultEvent.createEvent(channel,false,"Channel.Polling.Error","error",_loc4_);
  350.          _loc5_.rootCause = param1;
  351.          channel.dispatchEvent(_loc5_);
  352.       }
  353.    }
  354. }
  355.